home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / archiver / zoo21src.zoo / portable.c < prev    next >
C/C++ Source or Header  |  1991-07-24  |  22KB  |  723 lines
  1. #ifndef LINT
  2. /* @(#) portable.c 2.24 88/08/24 01:22:06 */
  3. static char sccsid[]="@(#) portable.c 2.24 88/08/24 01:22:06";
  4. #endif /* LINT */
  5.  
  6. #include "options.h"
  7. /*
  8. Copyright (C) 1986, 1987 Rahul Dhesi -- All rights reserved
  9. (C) Copyright 1988 Rahul Dhesi -- All rights reserved
  10. */
  11. /**********************
  12. portable.c contains functions needed to make Zoo portable to various
  13. implementations of C.
  14.  
  15. Note:  Provided a 2's complement machine is used, all functions in
  16. this file are themselves machine-independent and need not be changed
  17. when implementing Zoo on a different machine.  Some code will choke
  18. on 1's complement machines--I think.  
  19.  
  20. For machine-dependent declarations see files "machine.h" and "options.h". 
  21.  
  22. For machine-dependent functions see file "machine.c"
  23. */
  24.  
  25. #include "zoo.h"
  26. #include "zooio.h"
  27.  
  28. #include "various.h"
  29. #include "zoofns.h"
  30.  
  31. #include "machine.h"
  32. #include "debug.h"
  33. #include "assert.h"
  34.  
  35. #ifdef NEEDCTYP
  36. #include <ctype.h>              /* for tolower() */
  37. #endif
  38.  
  39. #include "portable.h"
  40.  
  41. #ifdef TRACE_IO
  42. extern int verbose;
  43. #endif
  44.  
  45. /* Functions defined for use within this file only.  */
  46. long to_long PARMS((BYTE[]));
  47. int to_int PARMS((BYTE[]));
  48. void b_to_zooh PARMS((struct zoo_header *, BYTE[]));
  49. void b_to_dir PARMS((struct direntry *, BYTE[]));
  50. int dir_to_b PARMS((BYTE[], struct direntry *));
  51. void zooh_to_b PARMS((BYTE[], struct zoo_header *));
  52. void splitlong PARMS((BYTE[], long));
  53. void splitint PARMS((BYTE[], int));
  54.  
  55. #ifdef TRACE_IO
  56. void show_h PARMS ((struct zoo_header *));
  57. void show_dir PARMS ((struct direntry *));
  58. #endif /* TRACE_IO */
  59.  
  60. extern unsigned int crccode;
  61.  
  62. /************************************************************************/
  63. /* I/O functions */
  64. /************************************************************************/
  65.  
  66. /* some functions get defined only if they aren't already macros */
  67.  
  68. #ifndef zooread
  69. int zooread (file, buffer, count)
  70. ZOOFILE file; char *buffer; int count;
  71. { return (fread (buffer, 1, count, file)); }
  72. #endif /* zooread */
  73.  
  74. #ifndef FIZ
  75. #ifndef zoowrite
  76. int zoowrite (file, buffer, count)
  77. ZOOFILE file; char *buffer; int count;
  78. { 
  79.     if (file == NULLFILE)
  80.        return (count);
  81.     else
  82.         return (fwrite (buffer, 1, count, file)); 
  83. }
  84. #endif /* zoowrite */
  85.  
  86. ZOOFILE zoocreate (fname)
  87. char *fname;
  88. { return ((ZOOFILE) fopen (fname, Z_NEW)); }
  89.  
  90. #endif /* FIZ */
  91.  
  92. #ifndef zooseek
  93. long zooseek (file, offset, whence)
  94. ZOOFILE file; long offset; int whence;
  95. { return (fseek (file, offset, whence)); }
  96. #endif /* zooseek */
  97.  
  98. ZOOFILE zooopen (fname, option)
  99. char *fname; char *option;
  100. { return ((ZOOFILE) fopen (fname, option)); }
  101.  
  102. #ifndef zootell
  103. long zootell (file)
  104. ZOOFILE file;
  105. { return ftell (file); }
  106. #endif /* zootell */
  107.  
  108. int zooclose (file)
  109. ZOOFILE file;
  110. { return fclose (file); }
  111.  
  112. /**********************
  113. low_ch() is a macro that returns a lowercased char; it may be
  114. used with any char, whether or not it is uppercase.   It will
  115. be used below by one or two functions.
  116. */
  117.  
  118. #define low_ch(c)        (isupper(c) ? tolower(c) : c)
  119.  
  120. /************************************************************************/
  121. /*** Following are functions that make up for various implementations ***/
  122. /*** of C not having certain library routines.                        ***/
  123. /************************************************************************/
  124.  
  125. #ifndef FIZ
  126. /**********************
  127. str_lwr() converts a string to lowercase and returns a pointer to the string
  128. */
  129. char *str_lwr (str)
  130. char *str;
  131. {
  132.    register char *s;
  133.    s = str;
  134.    while (*s != '\0') {
  135.       *s = toascii(*s);
  136.         *s = low_ch(*s);
  137.       s++;
  138.    }
  139.    return (str);
  140. }
  141.  
  142. /**********************
  143. str_icmp() compares strings just like strcmp() but it does it without regard to
  144. case.
  145. */
  146. int str_icmp (s1, s2)
  147. register char *s1, *s2;
  148. {
  149.    for ( ; low_ch(*s1) == low_ch(*s2);  s1++, s2++)
  150.       if (*s1 == '\0')
  151.          return(0);
  152.    return(low_ch(*s1) - low_ch(*s2));
  153. }
  154.  
  155. #ifdef NEED_MEMSET
  156. /**********************
  157. memset() it sets the first "count" bytes of "dest" to the character
  158. "c" and returns a pointer to "dest".
  159. */
  160. VOIDPTR memset (dest, c, count)
  161. register VOIDPTR dest;
  162. int c;
  163. unsigned count;
  164. {
  165.    register unsigned i;
  166.    for (i = 0; i < count; i++) {
  167.       *((char *) (dest + i)) = c;
  168.    }
  169.    return dest;
  170. }
  171. #endif /* NEED_MEMSET */
  172.  
  173. #ifdef NEED_MEMCPY
  174. /**********************
  175. memcpy() copies "count" bytes from "src" to "dest" and returns 
  176. a pointer to "dest".  Not necessarily safe for overlapping moves. */
  177.  
  178. VOIDPTR memcpy(dest, src, count)
  179. register VOIDPTR dest;
  180. register VOIDPTR src;
  181. unsigned count;
  182. {
  183.     VOIDPTR savedest = dest;
  184.     while (count > 0) {
  185.         *((char *) dest++) = *((char *) src++);
  186.         count--;
  187.     }
  188. }
  189. #endif /* NEED_MEMCPY */
  190.  
  191. #ifndef FPUTCHAR
  192. /**********************
  193. fputchar() writes a character to stdout.  It is identical to putchar
  194. but is a function, not a macro.
  195. */
  196. int fputchar (c)
  197. int c;
  198. {
  199.    return (fputc(c, stdout));
  200. }
  201. #endif /* FPUTCHAR */
  202. #endif /* FIZ */
  203.  
  204. /***********************************************************************/
  205. /*** Following are declarations and functions that are written in a  ***/
  206. /*** machine-independent way but they implement machine-dependent    ***/
  207. /*** activities                                                      ***/
  208. /***********************************************************************/
  209.  
  210. #ifndef DIRECT_CONVERT
  211. /**********************
  212. to_long() converts four consecutive bytes, in order of increasing
  213. significance, to a long integer.  It is used to make Zoo independent of the
  214. byte order of the system.  
  215. */
  216. long to_long(data)
  217. BYTE data[];
  218. {
  219.    return (long) ((unsigned long) data[0] | ((unsigned long) data[1] << 8) |
  220.          ((unsigned long) data[2] << 16) | ((unsigned long) data[3] << 24));
  221. }
  222.  
  223. #ifndef FIZ
  224. /********************
  225. splitlong() converts a long integer to four consecutive BYTEs in order
  226. of increasing significance.
  227. */
  228. void splitlong(bytes, bigword)
  229. BYTE bytes[];
  230. long bigword;
  231. {
  232.    int i;
  233.    for (i = 0; i < 4; i++) {
  234.       bytes[i] = bigword & 0xff;
  235.       bigword = (unsigned long) bigword >> 8;
  236.    }
  237. }     
  238. #endif /* FIZ */
  239.  
  240. /*******************
  241. splitint() converts an integer to two consecutive BYTEs in order
  242. of increasing significance.
  243. */
  244. void splitint(bytes, word)
  245. BYTE bytes[];
  246. int word;
  247. {
  248.    bytes[0] = word & 0xff;
  249.    word = (unsigned int) word >> 8;
  250.    bytes[1] = word & 0xff;
  251. }
  252.  
  253. /**********************
  254. to_int() converts two consecutive bytes, in order of increasing
  255. significance, to an integer, in a machine-independent manner
  256. */
  257. int to_int(data)
  258. BYTE data[];
  259. {
  260.    return (int) ((unsigned int) data[0] | ((unsigned int) data[1] << 8));
  261. }
  262.  
  263. #else /* else of ifndef DIRECT_CONVERT */
  264.  
  265. long to_long(data)
  266. BYTE data[];
  267. {
  268.    return ( * (long *) data );
  269. }
  270.  
  271. #ifndef FIZ
  272. /********************
  273. splitlong() converts a long integer to four consecutive BYTEs in order
  274. of increasing significance.
  275. */
  276. void splitlong(bytes, bigword)
  277. BYTE bytes[];
  278. long bigword;
  279. {
  280.    * (long *) bytes = bigword;
  281. }
  282. #endif /* FIZ */
  283.  
  284. /*******************
  285. splitint() converts an integer to two consecutive BYTEs in order
  286. of increasing significance.
  287. */
  288. void splitint(bytes, word)
  289. BYTE bytes[];
  290. int word;
  291. {
  292.    * (int *) bytes = word;
  293. }
  294.  
  295. /**********************
  296. to_int() converts two consecutive bytes, in order of increasing
  297. significance, to an integer.
  298. */
  299. int to_int(data)
  300. BYTE data[];
  301. {
  302.    return (*(int *) data);
  303. }
  304.  
  305. #endif /* ifndef DIRECT_CONVERT .. else ... */
  306.  
  307. #ifndef FIZ
  308. /**********************
  309. Function frd_zooh() reads the header of a Zoo archive in a machine-
  310. independent manner, from a ZOOFILE.
  311. */
  312. int frd_zooh(zoo_header, zoo_file)
  313. struct zoo_header *zoo_header;
  314. ZOOFILE zoo_file;
  315. {
  316.    int status;
  317.    BYTE bytes[SIZ_ZOOH];         /* canonical header representation */
  318. #ifdef TRACE_IO
  319.    if (verbose) {
  320.       printf("At file position [%8lx] ", ftell(zoo_file));
  321.    }
  322. #endif
  323.    status = zooread (zoo_file, (char *) bytes, SIZ_ZOOH);
  324.    b_to_zooh (zoo_header, bytes);   /* convert array to str